{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "   #  Normal Score Transform in Python for Engineers and Geoscientists \n",
    "\n",
    "## with GSLIB's DECLUS Program Converted to Python\n",
    "\n",
    "### Michael Pyrcz, Associate Professor, University of Texas at Austin \n",
    "\n",
    "\n",
    "#### Contacts: [Twitter/@GeostatsGuy](https://twitter.com/geostatsguy) | [GitHub/GeostatsGuy](https://github.com/GeostatsGuy) | [www.michaelpyrcz.com](http://michaelpyrcz.com) | [GoogleScholar](https://scholar.google.com/citations?user=QVZ20eQAAAAJ&hl=en&oi=ao) | [Book](https://www.amazon.com/Geostatistical-Reservoir-Modeling-Michael-Pyrcz/dp/0199731446)\n",
    "\n",
    "This is a tutorial for / demonstration of **Normal Score Transform / Gaussian Anamorphosis in Python with GSLIB's NSCORE program translated to Python, wrappers and reimplementations of other GSLIB: Geostatistical Library methods** (Deutsch and Journel, 1997). \n",
    "\n",
    "This exercise demonstrates the noraml score transform method in Python with wrappers and reimplimentation of GSLIB methods.  The steps include:\n",
    "\n",
    "1. general a random dataset\n",
    "2. transform to Gaussian\n",
    "3. visualize initial and transformed distributions\n",
    "4. visualize the cross plot of the transform table (q-q plot)\n",
    "\n",
    "To accomplish this I have provide wrappers or reimplementation in Python for the following GSLIB methods:\n",
    "\n",
    "1. sgsim - sequantial Gaussian simulation limited to 2D and unconditional\n",
    "2. hist - histograms plots reimplemented with GSLIB parameters using python methods\n",
    "3. locmap - location maps reimplemented with GSLIB parameters using python methods\n",
    "4. pixelplt - pixel plots reimplemented with GSLIB parameters using python methods\n",
    "5. locpix - my modification of GSLIB to superimpose a location map on a pixel plot reimplemented with GSLIB parameters using Python methods\n",
    "5. affine - affine correction adjust the mean and standard deviation of a feature reimplemented with GSLIB parameters using Python methods\n",
    "\n",
    "I have also started to translate the GSLIB support subfunctions to Python.\n",
    "\n",
    "The GSLIB source and executables are available at http://www.statios.com/Quick/gslib.html.  For the reference on using GSLIB check out the User Guide, GSLIB: Geostatistical Software Library and User's Guide by Clayton V. Deutsch and Andre G. Journel.\n",
    "\n",
    "I did this to allow people to use these GSLIB functions that are extremely robust in Python. Also this should be a bridge to allow so many familar with GSLIB to work in Python as a kept the parameterization and displays consistent with GSLIB.  The wrappers are simple functions declared below that write the parameter files, run the GSLIB executable in the working directory and load and visualize the output in Python. This will be included on GitHub for anyone to try it out https://github.com/GeostatsGuy/.  \n",
    "\n",
    "This was my first effort to translate the GSLIB Fortran to Python.  It was pretty easy so I'll start translating other critical GSLIB functions.\n",
    "\n",
    "#### Load the required libraries\n",
    "\n",
    "The following code loads the required libraries."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 216,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os                                                 # to set current working directory \n",
    "import numpy as np                                        # arrays and matrix math\n",
    "import pandas as pd                                       # DataFrames\n",
    "import matplotlib.pyplot as plt                           # plotting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you get a package import error, you may have to first install some of these packages. This can usually be accomplished by opening up a command window on Windows and then typing 'python -m pip install [package-name]'. More assistance is available with the respective package docs.  \n",
    "\n",
    "#### Declare functions\n",
    "\n",
    "Here are the wrappers and reimplementations of GSLIB method along with two utilities to load GSLIB's Geo-EAS from data files into DataFrames and 2D Numpy arrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 217,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Some GeostatsPy Functions - by Michael Pyrcz, maintained at https://git.io/fNgR7.\n",
    "# A set of functions to provide access to GSLIB in Python.\n",
    "# GSLIB executables: nscore.exe, declus.exe, gam.exe, gamv.exe, vmodel.exe, kb2d.exe & sgsim.exe must be in the working directory \n",
    "import pandas as pd\n",
    "import os\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt                          \n",
    "import random as rand\n",
    "image_type = 'tif'; dpi = 600\n",
    "\n",
    "# utility to convert GSLIB Geo-EAS files to a 1D or 2D numpy ndarray for use with Python methods\n",
    "def GSLIB2ndarray(data_file,kcol,nx,ny): \n",
    "    colArray = []\n",
    "    if ny > 1:\n",
    "        array = np.ndarray(shape=(ny,nx),dtype=float,order='F')\n",
    "    else:\n",
    "        array = np.zeros(nx)    \n",
    "    with open(data_file) as myfile:   # read first two lines\n",
    "        head = [next(myfile) for x in range(2)]\n",
    "        line2 = head[1].split()\n",
    "        ncol = int(line2[0])          # get the number of columns\n",
    "        for icol in range(0, ncol):   # read over the column names\n",
    "            head = [next(myfile) for x in range(1)]\n",
    "            if icol == kcol:\n",
    "                col_name = head[0].split()[0]       \n",
    "        if ny > 1:\n",
    "            for iy in range(0,ny):\n",
    "                for ix in range(0,nx):\n",
    "                    head = [next(myfile) for x in range(1)]\n",
    "                    array[ny-1-iy][ix] = head[0].split()[kcol]\n",
    "        else:\n",
    "            for ix in range(0,nx):\n",
    "                head = [next(myfile) for x in range(1)]\n",
    "                array[ix] = head[0].split()[kcol]\n",
    "    return array,col_name \n",
    "\n",
    "# utility to convert GSLIB Geo-EAS files to a pandas DataFrame for use with Python methods\n",
    "def GSLIB2Dataframe(data_file):\n",
    "    colArray = []\n",
    "    with open(data_file) as myfile:   # read first two lines\n",
    "        head = [next(myfile) for x in range(2)]\n",
    "        line2 = head[1].split()\n",
    "        ncol = int(line2[0])\n",
    "        for icol in range(0, ncol):\n",
    "            head = [next(myfile) for x in range(1)]\n",
    "            colArray.append(head[0].split()[0])\n",
    "        data = np.loadtxt(myfile, skiprows = 0)\n",
    "        df = pd.DataFrame(data)\n",
    "        df.columns = colArray\n",
    "        return df\n",
    "\n",
    "# histogram, reimplemented in Python of GSLIB hist with MatPlotLib methods, displayed and as image file\n",
    "def hist(array,xmin,xmax,log,cumul,bins,weights,xlabel,title,fig_name):\n",
    "    plt.figure(figsize=(8,6))\n",
    "    cs = plt.hist(array, alpha = 0.2, color = 'red', edgecolor = 'black', bins=bins, range = [xmin,xmax], weights = weights, log = log, cumulative = cumul)\n",
    "    plt.title(title)\n",
    "    plt.xlabel(xlabel); plt.ylabel('Frequency')  \n",
    "    plt.savefig(fig_name + '.' + image_type,dpi=dpi)\n",
    "    plt.show()\n",
    "    return\n",
    "\n",
    "# histogram, reimplemented in Python of GSLIB hist with MatPlotLib methods (version for subplots)\n",
    "def hist_st(array,xmin,xmax,log,cumul,bins,weights,xlabel,title):  \n",
    "    cs = plt.hist(array, alpha = 0.2, color = 'red', edgecolor = 'black', bins=bins, range = [xmin,xmax], weights = weights, log = log, cumulative = cumul)\n",
    "    plt.title(title)\n",
    "    plt.xlabel(xlabel); plt.ylabel('Frequency') \n",
    "    return\n",
    "\n",
    "# location map, reimplemention in Python of GSLIB locmap with MatPlotLib methods\n",
    "def locmap(df,xcol,ycol,vcol,xmin,xmax,ymin,ymax,vmin,vmax,title,xlabel,ylabel,vlabel,cmap,fig_name):\n",
    "    ixy = 0 \n",
    "    plt.figure(figsize=(8,6))    \n",
    "    im = plt.scatter(df[xcol],df[ycol],s=None, c=df[vcol], marker=None, cmap=cmap, norm=None, vmin=vmin, vmax=vmax, alpha=0.8, linewidths=0.8, verts=None, edgecolors=\"black\")\n",
    "    plt.title(title)\n",
    "    plt.xlim(xmin,xmax)\n",
    "    plt.ylim(ymin,ymax)    \n",
    "    plt.xlabel(xlabel)\n",
    "    plt.ylabel(ylabel)\n",
    "    cbar = plt.colorbar(im, orientation = 'vertical',ticks=np.linspace(vmin,vmax,10))\n",
    "    cbar.set_label(vlabel, rotation=270, labelpad=20)\n",
    "    plt.savefig(fig_name + '.' + image_type,dpi=dpi)\n",
    "    plt.show()\n",
    "    return im\n",
    "\n",
    "# location map, reimplemention in Python of GSLIB locmap with MatPlotLib methods (version for subplots)\n",
    "def locmap_st(df,xcol,ycol,vcol,xmin,xmax,ymin,ymax,vmin,vmax,title,xlabel,ylabel,vlabel,cmap):\n",
    "    ixy = 0   \n",
    "    im = plt.scatter(df[xcol],df[ycol],s=None, c=df[vcol], marker=None, cmap=cmap, norm=None, vmin=vmin, vmax=vmax, alpha=0.8, linewidths=0.8, verts=None, edgecolors=\"black\")\n",
    "    plt.title(title)\n",
    "    plt.xlim(xmin,xmax)\n",
    "    plt.ylim(ymin,ymax)    \n",
    "    plt.xlabel(xlabel)\n",
    "    plt.ylabel(ylabel)\n",
    "    cbar = plt.colorbar(im, orientation = 'vertical',ticks=np.linspace(vmin,vmax,10))\n",
    "    cbar.set_label(vlabel, rotation=270, labelpad=20)\n",
    "    return im           \n",
    "\n",
    "# pixel plot, reimplemention in Python of GSLIB pixelplt with MatPlotLib methods\n",
    "def pixelplt(array,xmin,xmax,ymin,ymax,step,vmin,vmax,title,xlabel,ylabel,vlabel,cmap,fig_name):\n",
    "    print(str(step))\n",
    "    xx, yy = np.meshgrid(np.arange(xmin, xmax, step),np.arange(ymax, ymin, -1*step))\n",
    "    plt.figure(figsize=(8,6))\n",
    "    im = plt.contourf(xx,yy,array,cmap=cmap,vmin=vmin,vmax=vmax,levels=np.linspace(vmin,vmax,100))\n",
    "    plt.title(title)\n",
    "    plt.xlabel(xlabel)\n",
    "    plt.ylabel(ylabel)\n",
    "    cbar = plt.colorbar(im,orientation = 'vertical',ticks=np.linspace(vmin,vmax,10))\n",
    "    cbar.set_label(vlabel, rotation=270, labelpad=20)\n",
    "    plt.savefig(fig_name + '.' + image_type,dpi=dpi)\n",
    "    plt.show()\n",
    "    return im\n",
    "\n",
    "# pixel plot, reimplemention in Python of GSLIB pixelplt with MatPlotLib methods(version for subplots)\n",
    "def pixelplt_st(array,xmin,xmax,ymin,ymax,step,vmin,vmax,title,xlabel,ylabel,vlabel,cmap):\n",
    "    xx, yy = np.meshgrid(np.arange(xmin, xmax, step),np.arange(ymax, ymin, -1*step))\n",
    "    ixy = 0 \n",
    "    x = [];y = []; v = [] # use dummy since scatter plot controls legend min and max appropriately and contour does not!\n",
    "    cs = plt.contourf(xx,yy,array,cmap=cmap,vmin=vmin,vmax=vmax,levels = np.linspace(vmin,vmax,100))\n",
    "    im = plt.scatter(x,y,s=None, c=v, marker=None,cmap=cmap, vmin=vmin, vmax=vmax, alpha=0.8, linewidths=0.8, verts=None, edgecolors=\"black\")\n",
    "    plt.title(title)\n",
    "    plt.xlabel(xlabel)\n",
    "    plt.ylabel(ylabel)\n",
    "    plt.clim(vmin,vmax)\n",
    "    cbar = plt.colorbar(im, orientation = 'vertical')\n",
    "    cbar.set_label(vlabel, rotation=270, labelpad=20)\n",
    "    return cs\n",
    "\n",
    "# pixel plot and location map, reimplementation in Python of a GSLIB MOD with MatPlotLib methods\n",
    "def locpix(array,xmin,xmax,ymin,ymax,step,vmin,vmax,df,xcol,ycol,vcol,title,xlabel,ylabel,vlabel,cmap,fig_name):\n",
    "    xx, yy = np.meshgrid(np.arange(xmin, xmax, step),np.arange(ymax, ymin, -1*step))\n",
    "    ixy = 0 \n",
    "    plt.figure(figsize=(8,6))\n",
    "    cs = plt.contourf(xx, yy, array, cmap=cmap,vmin=vmin, vmax=vmax,levels = np.linspace(vmin,vmax,100))\n",
    "    im = plt.scatter(df[xcol],df[ycol],s=None, c=df[vcol], marker=None, cmap=cmap, vmin=vmin, vmax=vmax, alpha=0.8, linewidths=0.8, verts=None, edgecolors=\"black\")\n",
    "    plt.title(title)\n",
    "    plt.xlabel(xlabel)\n",
    "    plt.ylabel(ylabel)\n",
    "    plt.xlim(xmin,xmax)\n",
    "    plt.ylim(ymin,ymax)  \n",
    "    cbar = plt.colorbar(orientation = 'vertical')\n",
    "    cbar.set_label(vlabel, rotation=270, labelpad=20)\n",
    "    plt.savefig(fig_name + '.' + image_type,dpi=dpi)\n",
    "    plt.show()\n",
    "    return cs\n",
    "\n",
    "# pixel plot and location map, reimplementation in Python of a GSLIB MOD with MatPlotLib methods(version for subplots)\n",
    "def locpix_st(array,xmin,xmax,ymin,ymax,step,vmin,vmax,df,xcol,ycol,vcol,title,xlabel,ylabel,vlabel,cmap):\n",
    "    xx, yy = np.meshgrid(np.arange(xmin, xmax, step),np.arange(ymax, ymin, -1*step))\n",
    "    ixy = 0 \n",
    "    cs = plt.contourf(xx, yy, array, cmap=cmap,vmin=vmin, vmax=vmax,levels = np.linspace(vmin,vmax,100))\n",
    "    im = plt.scatter(df[xcol],df[ycol],s=None, c=df[vcol], marker=None, cmap=cmap, vmin=vmin, vmax=vmax, alpha=0.8, linewidths=0.8, verts=None, edgecolors=\"black\")\n",
    "    plt.title(title)\n",
    "    plt.xlabel(xlabel)  \n",
    "    plt.ylabel(ylabel)\n",
    "    plt.xlim(xmin,xmax)\n",
    "    plt.ylim(ymin,ymax)\n",
    "    cbar = plt.colorbar(orientation = 'vertical')\n",
    "    cbar.set_label(vlabel, rotation=270, labelpad=20)\n",
    "\n",
    "# affine distribution correction reimplemented in Python with numpy methods \n",
    "def affine(array,tmean,tstdev): \n",
    "    mean = np.average(array)\n",
    "    stdev = np.std(array)  \n",
    "    array = (tstdev/stdev)*(array - mean) + tmean\n",
    "    return(array)   \n",
    "\n",
    "def make_variogram(nug,nst,it1,cc1,azi1,hmaj1,hmin1,it2=1,cc2=0,azi2=0,hmaj2=0,hmin2=0):\n",
    "    if cc2 == 0:\n",
    "        nst = 1\n",
    "    var = dict([('nug', nug), ('nst', nst), ('it1', it1),('cc1', cc1),('azi1', azi1),('hmaj1', hmaj1), ('hmin1', hmin1), \n",
    "      ('it2', it2),('cc2', cc2),('azi2', azi2),('hmaj2', hmaj2), ('hmin2', hmin2)])\n",
    "    if nug + cc1 + cc2 != 1:\n",
    "        print('\\x1b[0;30;41m make_variogram Warning: sill does not sum to 1.0, do not use in simulation \\x1b[0m')\n",
    "    if cc1 < 0 or cc2 < 0 or nug < 0 or hmaj1 < 0 or hmaj2 < 0 or hmin1 < 0 or hmin2 < 0:\n",
    "        print('\\x1b[0;30;41m make_variogram Warning: contributions and ranges must be all positive \\x1b[0m')\n",
    "    if hmaj1 < hmin1 or hmaj2 < hmin2:\n",
    "        print('\\x1b[0;30;41m make_variogram Warning: major range should be greater than minor range \\x1b[0m')\n",
    "    return var\n",
    "    \n",
    "# sequential Gaussian simulation, 2D unconditional wrapper for sgsim from GSLIB (.exe must be in working directory)\n",
    "def GSLIB_sgsim_2d_uncond(nreal,nx,ny,hsiz,seed,var,output_file):\n",
    "    import os\n",
    "    import numpy as np \n",
    "    \n",
    "    nug = var['nug']\n",
    "    nst = var['nst']; it1 = var['it1']; cc1 = var['cc1']; azi1 = var['azi1']; hmaj1 = var['hmaj1']; hmin1 = var['hmin1'] \n",
    "    it2 = var['it2']; cc2 = var['cc2']; azi2 = var['azi2']; hmaj2 = var['hmaj2']; hmin2 = var['hmin2']     \n",
    "    max_range = max(hmaj1,hmaj2) \n",
    "    hmn = hsiz * 0.5   \n",
    "    hctab = int(max_range/hsiz)*2 + 1\n",
    "    \n",
    "    sim_array = np.random.rand(nx,ny)\n",
    "  \n",
    "    file = open(\"sgsim.par\", \"w\")\n",
    "    file.write(\"              Parameters for SGSIM                                         \\n\")\n",
    "    file.write(\"              ********************                                         \\n\")\n",
    "    file.write(\"                                                                           \\n\")\n",
    "    file.write(\"START OF PARAMETER:                                                        \\n\")\n",
    "    file.write(\"none                          -file with data                              \\n\")\n",
    "    file.write(\"1  2  0  3  5  0              -  columns for X,Y,Z,vr,wt,sec.var.          \\n\")\n",
    "    file.write(\"-1.0e21 1.0e21                -  trimming limits                           \\n\")\n",
    "    file.write(\"0                             -transform the data (0=no, 1=yes)            \\n\")\n",
    "    file.write(\"none.trn                      -  file for output trans table               \\n\")\n",
    "    file.write(\"1                             -  consider ref. dist (0=no, 1=yes)          \\n\")\n",
    "    file.write(\"none.dat                      -  file with ref. dist distribution          \\n\")\n",
    "    file.write(\"1  0                          -  columns for vr and wt                     \\n\")\n",
    "    file.write(\"-4.0    4.0                   -  zmin,zmax(tail extrapolation)             \\n\")\n",
    "    file.write(\"1      -4.0                   -  lower tail option, parameter              \\n\")\n",
    "    file.write(\"1       4.0                   -  upper tail option, parameter              \\n\")\n",
    "    file.write(\"0                             -debugging level: 0,1,2,3                    \\n\")\n",
    "    file.write(\"nonw.dbg                      -file for debugging output                   \\n\")\n",
    "    file.write(str(output_file) + \"           -file for simulation output                  \\n\")\n",
    "    file.write(str(nreal) + \"                 -number of realizations to generate          \\n\")\n",
    "    file.write(str(nx) + \" \" + str(hmn) + \" \" + str(hsiz) + \"                              \\n\")\n",
    "    file.write(str(ny) + \" \" + str(hmn) + \" \" + str(hsiz) + \"                              \\n\")\n",
    "    file.write(\"1 0.0 1.0                     - nz zmn zsiz                                \\n\")\n",
    "    file.write(str(seed) + \"                  -random number seed                          \\n\")\n",
    "    file.write(\"0     8                       -min and max original data for sim           \\n\")\n",
    "    file.write(\"12                            -number of simulated nodes to use            \\n\")\n",
    "    file.write(\"0                             -assign data to nodes (0=no, 1=yes)          \\n\")\n",
    "    file.write(\"1     3                       -multiple grid search (0=no, 1=yes),num      \\n\")\n",
    "    file.write(\"0                             -maximum data per octant (0=not used)        \\n\")\n",
    "    file.write(str(max_range) + \" \" + str(max_range) + \" 1.0 -maximum search  (hmax,hmin,vert) \\n\")\n",
    "    file.write(str(azi1) + \"   0.0   0.0       -angles for search ellipsoid                 \\n\")\n",
    "    file.write(str(hctab) + \" \" + str(hctab) + \" 1 -size of covariance lookup table        \\n\")\n",
    "    file.write(\"0     0.60   1.0              -ktype: 0=SK,1=OK,2=LVM,3=EXDR,4=COLC        \\n\")\n",
    "    file.write(\"none.dat                      -  file with LVM, EXDR, or COLC variable     \\n\")\n",
    "    file.write(\"4                             -  column for secondary variable             \\n\")\n",
    "    file.write(str(nst) + \" \" + str(nug) + \"  -nst, nugget effect                          \\n\")\n",
    "    file.write(str(it1) + \" \" + str(cc1) + \" \" +str(azi1) + \" 0.0 0.0 -it,cc,ang1,ang2,ang3\\n\")\n",
    "    file.write(\" \" + str(hmaj1) + \" \" + str(hmin1) + \" 1.0 - a_hmax, a_hmin, a_vert        \\n\")\n",
    "    file.write(str(it2) + \" \" + str(cc2) + \" \" +str(azi2) + \" 0.0 0.0 -it,cc,ang1,ang2,ang3\\n\")\n",
    "    file.write(\" \" + str(hmaj2) + \" \" + str(hmin2) + \" 1.0 - a_hmax, a_hmin, a_vert        \\n\")  \n",
    "    file.close()\n",
    "\n",
    "    os.system('\"sgsim.exe sgsim.par\"')       \n",
    "    sim_array = GSLIB2ndarray(output_file,0,nx,ny)         \n",
    "    return(sim_array[0])\n",
    "\n",
    "# extract regular spaced samples from a model   \n",
    "def regular_sample(array,xmin,xmax,ymin,ymax,step,mx,my,name):\n",
    "    x = []; y = []; v = []; iix = 0; iiy = 0;\n",
    "    xx, yy = np.meshgrid(np.arange(xmin, xmax, step),np.arange(ymax, ymin, -1*step))\n",
    "    iiy = 0\n",
    "    for iy in range(0,ny):\n",
    "        if iiy >= my:\n",
    "            iix = 0\n",
    "            for ix in range(0,nx):\n",
    "                if iix >= mx:\n",
    "                    x.append(xx[ix,iy]);y.append(yy[ix,iy]); v.append(array[ix,iy])\n",
    "                    iix = 0; iiy = 0\n",
    "                iix = iix + 1\n",
    "        iiy = iiy + 1\n",
    "    df = pd.DataFrame(np.c_[x,y,v],columns=['X', 'Y', name])\n",
    "    return(df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These are a variety of GSLIB sub functions required by the NSCORE function that I have converted to Python.  I will continue to convert the subfunctions and include them as needed by the GSLIB functions that I convert."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 218,
   "metadata": {},
   "outputs": [],
   "source": [
    "def dlocate(xx,iis,iie,x):\n",
    "    from bisect import bisect\n",
    "    n = len(xx)\n",
    "    if iie <= iis:\n",
    "        iis = 0; ie = n-1\n",
    "    array = xx[iis:iie-1]  # this is accounting for swith to 0,...,n-1 index\n",
    "    j = bisect(array,x)\n",
    "    return j\n",
    "\n",
    "def dsortem(ib,ie,a,iperm,b=0,c=0,d=0,e=0,f=0,g=0,h=0):\n",
    "    a = a[ib:ie]\n",
    "    inds = a.argsort()\n",
    "    a = np.copy(a[inds]) # deepcopy forces pass to outside scope\n",
    "    if(iperm == 1):\n",
    "        return a\n",
    "    b_slice = b[ib:ie]\n",
    "    b = b_slice[inds]    \n",
    "    if iperm == 2:\n",
    "        return a,b\n",
    "    c_slice = c[ib:ie]\n",
    "    c = c_slice[inds]    \n",
    "    if iperm == 3:\n",
    "        return a, b, c\n",
    "    d_slice = d[ib:ie]\n",
    "    d = d_slice[inds]    \n",
    "    if iperm == 4:\n",
    "        return a, b, c, d\n",
    "    e_slice = e[ib:ie]\n",
    "    e = e_slice[inds]    \n",
    "    if iperm == 5:\n",
    "        return a, b, c, d, e \n",
    "    f_slice = f[ib:ie]\n",
    "    f = f_slice[inds]\n",
    "    if iperm == 6:\n",
    "        return a, b, c, d, e, f \n",
    "    g_slice = g[ib:ie]\n",
    "    g = g_slice[inds]\n",
    "    if iperm == 7:\n",
    "        return a, b, c, d, e, f, h     \n",
    "    h_slice = h[ib:ie]\n",
    "    h = h_slice[inds]\n",
    "    return a, b, c, d, e, f, h\n",
    "\n",
    "def gauinv(p):\n",
    "    lim = 1.0e-10; p0 = -0.322232431088; p1 = -1.0; p2 = -0.342242088547\n",
    "    p3 = -0.0204231210245; p4 = -0.0000453642210148; q0 = 0.0993484626060\n",
    "    q1 = 0.588581570495; q2 = 0.531103462366; q3 = 0.103537752850; q4 = 0.0038560700634\n",
    "\n",
    "# Check for an error situation:\n",
    "    if p < lim:\n",
    "        xp = -1.0e10\n",
    "        return xp\n",
    "    if p > (1.0-lim):\n",
    "        xp =  1.0e10\n",
    "        return xp    \n",
    "\n",
    "# Get k for an error situation:\n",
    "    pp = p\n",
    "    if p > 0.5: pp = 1 - pp\n",
    "    xp   = 0.0\n",
    "    if p == 0.5: \n",
    "        return xp\n",
    "\n",
    "# Approximate the function:\n",
    "    y  = np.sqrt(np.log(1.0/(pp*pp)))\n",
    "    xp = float(y + ((((y*p4+p3)*y+p2)*y+p1)*y+p0) /\n",
    "            ((((y*q4+q3)*y+q2)*y+q1)*y+q0) )\n",
    "    if float(p) == float(pp): \n",
    "        xp = -xp\n",
    "    return xp\n",
    "\n",
    "def gcum(x):\n",
    "    z = x\n",
    "    if z < 0:  \n",
    "        z = -z\n",
    "    t= 1./(1.+ 0.2316419*z)\n",
    "    gcum = t*(0.31938153   + t*(-0.356563782 + t*(1.781477937 +\n",
    "           t*(-1.821255978 + t*1.330274429))))\n",
    "    e2= 0.0\n",
    "    \n",
    "# standard deviations out gets treated as infinity:\n",
    "    if z <= 6: \n",
    "        e2 = np.exp(-z*z/2.0)*0.3989422803\n",
    "    gcum = 1.0- e2 * gcum\n",
    "    if x >= 0.0: \n",
    "        return gcum\n",
    "    gcum = 1.0 - gcum\n",
    "    return gcum\n",
    "\n",
    "def dpowint(xlow,xhigh,ylow,yhigh,xval,pwr):\n",
    "    EPSLON = 1.0e-20\n",
    "    if (xhigh-xlow) < EPSLON:\n",
    "        dpowint = (yhigh+ylow)/2.0\n",
    "    else:\n",
    "        dpowint = ylow + (yhigh-ylow)*(((xval-xlow)/(xhigh-xlow))**pwr)\n",
    "    return dpowint\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's the NSCORE function translated from the original Fortran.  I used Python functionality ot streamline the code, but otherwise this should be true to the original program."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 317,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "# GSLIB's NSCORE program (Deutsch and Journel, 1998) converted from the original Fortran to Python \n",
    "# by Michael Pyrcz, the University of Texas at Austin (Jan, 2019)\n",
    "def nscore(df,vcol,wcol=0,ismooth=0,dfsmooth=0,smcol=0,smwcol=0):\n",
    "# Parameters - consistent with original GSLIB    \n",
    "# df - Pandas DataFrame with the spatial data\n",
    "# vcol - name of the variable column\n",
    "# wcol (optional) - name of the weigth column, if not included assumes equal weighting\n",
    "# ismooth - if 1 then use a reference distribution \n",
    "# dfsmooth - Pandas DataFrame required if reference distribution is used\n",
    "# smcol, smwtcol - reference distribution property and weight required if reference distribution is used\n",
    "#\n",
    "# Set constants\n",
    "    np.random.seed(73073)\n",
    "    pwr = 1.0                         # interpolation power, hard coded to 1.0 in GSLIB\n",
    "    EPSILON = 1.0e-20\n",
    "\n",
    "# Decide which file to use for establishing the transformation table:\n",
    "    if ismooth == 1: \n",
    "        nd = len(dfsmooth)\n",
    "        vr = dfsmooth[smcol].values\n",
    "        wt_ns = np.ones(nd)\n",
    "        if smwcol != 0:\n",
    "            wt_ns = dfsmooth[smwcol].values \n",
    "    else:\n",
    "        nd = len(df)\n",
    "        vr = df[vcol].values\n",
    "        wt_ns = np.ones(nd)\n",
    "        if wcol != 0:\n",
    "            wt_ns = df[wcol].values\n",
    "    twt = np.sum(wt_ns)\n",
    "\n",
    "# Sort data by value:\n",
    "    istart = 0\n",
    "    iend   = nd\n",
    "    vr, wt_ns = dsortem(istart,iend,vr,2,wt_ns)\n",
    "\n",
    "# Compute the cumulative probabilities and write transformation table\n",
    "    wtfac = 1.0/twt\n",
    "    oldcp = 0.0\n",
    "    cp    = 0.0\n",
    "    for j in range(istart,iend):  \n",
    "        w = wtfac*wt_ns[j]\n",
    "        cp = cp + w\n",
    "        wt_ns[j] = (cp + oldcp)/2.0\n",
    "        vrrg = gauinv(wt_ns[j])\n",
    "        vrg = float(vrrg)\n",
    "        oldcp =  cp\n",
    "\n",
    "# Now, reset the weight to the normal scores value:\n",
    "        wt_ns[j] = vrg\n",
    "    \n",
    "# Normal Scores Transform:\n",
    "\n",
    "    nd_trans = len(df)\n",
    "    ns = np.zeros(nd_trans)\n",
    "    val = df[vcol].values\n",
    "    for i in range(0,nd_trans): \n",
    "        vrr = val[i] + np.random.rand() * EPSILON\n",
    "\n",
    "# Now, get the normal scores value for \"vrr\" \n",
    "        j = dlocate(vr,1,nd,vrr)\n",
    "        j   = min(max(1,j),(nd-1))\n",
    "        ns[i] = dpowint(vr[j],vr[j+1],wt_ns[j],wt_ns[j+1],vrr,pwr)\n",
    "        #print(vrr,ns[i])\n",
    "    return ns, vr, wt_ns"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's a simple test of the NSCORE code with visualizations to check the results including the original and transform distributions, p-p plot of the transform table.\n",
    "\n",
    "#### Set the working directory\n",
    "\n",
    "I always like to do this so I don't lose files and to simplify subsequent read and writes (avoid including the full address each time).  Also, in this case make sure to place the required (see above) GSLIB executables in this directory or a location identified in the environmental variable *Path*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "os.chdir(\"c:/PGE337/DataAnalysis\")                                   # set the working directory"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You will have to update the part in quotes with your own working directory and the format is different on a Mac (e.g. \"~/PGE\"). \n",
    "\n",
    "##### Demonstrations / Benchmarks\n",
    "\n",
    "Let's start with just a random 1D ndarray, add it to a Pandas DataFrame and convert it to standard normal distributed. We will add weights next and then consider a reference distribution after that."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 318,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "t = np.random.rand(500)\n",
    "t = affine(t,10.0,3.0)\n",
    "df = pd.DataFrame({'t':t})\n",
    "ns, tab_vr, tab_ns = nscore(df,'t')\n",
    "\n",
    "plt.subplot(221)\n",
    "hist_st(t,0.0,20.0,log=False,cumul=False,bins=20,weights=None,xlabel=\"Porosity (%)\",title=\"Porosity\")\n",
    "plt.ylim(0.0,100)\n",
    "\n",
    "plt.subplot(222)\n",
    "hist_st(ns,-4.0,4.0,log=False,cumul=False,bins=20,weights=None,xlabel=\"Porosity (%)\",title=\"Transformed Porosity\")\n",
    "plt.ylim(0.0,100)\n",
    "\n",
    "plt.subplot(223)\n",
    "plt.scatter(tab_vr,tab_ns, c = \"black\", marker='o', alpha = 0.2, edgecolors = \"none\")\n",
    "plt.xlabel('Porosity (%)')\n",
    "plt.ylabel('Normal Score Transformed Porosity')\n",
    "plt.title('Normal Score Transformed Porosity vs Untransformed Porosity p-p Plot')\n",
    "plt.ylim(-4,4)\n",
    "plt.xlim(0,30)\n",
    "\n",
    "plt.subplots_adjust(left=0.0, bottom=0.0, right=2.0, top=3.5, wspace=0.2, hspace=0.2)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's an example with data weights applied.  For simple demosntration, I use random weights.  This would typical be accomplished with declustering weights."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 322,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "t = np.random.rand(500)\n",
    "t = affine(t,10.0,3.0)\n",
    "wts = np.random.rand(500)\n",
    "wts = affine(wts,1.0,0.25)\n",
    "df = pd.DataFrame({'t':t,'wts':wts})\n",
    "ns, tab_vr, tab_ns = nscore(df,'t','wts')\n",
    "\n",
    "plt.subplot(221)\n",
    "hist_st(t,0.0,20.0,log=False,cumul=False,bins=20,weights=None,xlabel=\"Porosity (%)\",title=\"Porosity\")\n",
    "plt.ylim(0.0,100)\n",
    "\n",
    "plt.subplot(222)\n",
    "hist_st(ns,-4.0,4.0,log=False,cumul=False,bins=20,weights=None,xlabel=\"Porosity (%)\",title=\"Transformed Porosity\")\n",
    "plt.ylim(0.0,100)\n",
    "\n",
    "plt.subplot(223)\n",
    "plt.scatter(tab_vr,tab_ns, c = \"black\", marker='o', alpha = 0.2, edgecolors = \"none\")\n",
    "plt.xlabel('Porosity (%)')\n",
    "plt.ylabel('Normal Score Transformed Porosity')\n",
    "plt.title('Normal Score Transformed Porosity vs Untransformed Porosity p-p Plot')\n",
    "plt.ylim(-4,4)\n",
    "plt.xlim(0,30)\n",
    "\n",
    "plt.subplots_adjust(left=0.0, bottom=0.0, right=2.0, top=3.5, wspace=0.2, hspace=0.2)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's an example with reference distribution.  Care should be taken with this method and reference distributions as there is not tail extrapolation to hand values outside the range of the reference distribution."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 325,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "ref = np.random.rand(500)\n",
    "ref = affine(ref,10.0,3.0)\n",
    "\n",
    "df_ref = pd.DataFrame({'ref':ref})\n",
    "t = np.random.rand(10)\n",
    "t = affine(t,10,3.0)\n",
    "df_t = pd.DataFrame({'t':t})\n",
    "\n",
    "ns, tab_vr, tab_ns = nscore(df_t,'t',wcol=0,ismooth=1,dfsmooth=df_ref,smcol='ref',smwcol=0)\n",
    "\n",
    "plt.subplot(221)\n",
    "hist_st(t,0.0,20.0,log=False,cumul=False,bins=20,weights=None,xlabel=\"Porosity (%)\",title=\"Porosity\")\n",
    "plt.ylim(0.0,5)\n",
    "\n",
    "plt.subplot(222)\n",
    "hist_st(ref,0.0,20.0,log=False,cumul=False,bins=20,weights=None,xlabel=\"Porosity (%)\",title=\"Reference Distribution\")\n",
    "plt.ylim(0.0,100)\n",
    "\n",
    "plt.subplot(223)\n",
    "hist_st(ns,-4.0,4.0,log=False,cumul=False,bins=20,weights=None,xlabel=\"Porosity (%)\",title=\"Transformed Porosity\")\n",
    "plt.ylim(0.0,5)\n",
    "\n",
    "plt.subplot(224)\n",
    "plt.scatter(tab_vr,tab_ns, c = \"black\", marker='o', alpha = 0.2, edgecolors = \"none\")\n",
    "plt.xlabel('Porosity (%)')\n",
    "plt.ylabel('Normal Score Transformed Porosity')\n",
    "plt.title('Normal Score Transformed Porosity vs Untransformed Porosity p-p Plot')\n",
    "plt.ylim(-4,4)\n",
    "plt.xlim(0,30)\n",
    "\n",
    "plt.subplots_adjust(left=0.0, bottom=0.0, right=2.0, top=2.5, wspace=0.2, hspace=0.2)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I hope you find this code and demonstration useful. I'm always happy to discuss geostatistics, statistical modeling, uncertainty modeling and machine learning,\n",
    "\n",
    "*Michael*\n",
    "\n",
    "**Michael Pyrcz**, Ph.D., P.Eng. Associate Professor The Hildebrand Department of Petroleum and Geosystems Engineering, Bureau of Economic Geology, The Jackson School of Geosciences, The University of Texas at Austin\n",
    "On Twitter I'm the **GeostatsGuy** and on YouTube my lectures are on the channel, **GeostatsGuy Lectures**."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
